package com.example.common.util;

import java.math.BigDecimal;
import java.text.ParseException;
import java.util.Date;

/**
 * 类型转换类
 * @version 1.0 createTime:2019/5/8 15:46
 * @author weicong
 */
public class Convert {

    /**
     * 对象转换成字符串
     * @param value
     * @param defaultValue
     * @return
     */
    public static String toString(Object value, String defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof String){
            return (String) value;
        }
        return String.valueOf(value);
    }

    /**
     * 对象转字符串
     * @param value
     * @return
     */
    public static String toString(Object value){
        return toString(value, null);
    }

    /**
     * 对象转换成boolean
     * @param value
     * @param defaultValue
     * @return
     */
    public static Boolean toBoolean(Object value, Boolean defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Boolean){
            return (Boolean) value;
        }
        return Boolean.parseBoolean(value.toString());
    }

    /**
     * 对象转boolean
     * @param value
     * @return
     */
    public static Boolean toBoolean(Object value){
        return toBoolean(value, null);
    }

    /**
     * 对象转换成integer
     * @param value
     * @param defaultValue
     * @return
     */
    public static Integer toInteger(Object value, Integer defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Integer){
            return (Integer)value;
        }
        return Integer.parseInt(value.toString());
    }

    /**
     * 对象转integer
     * @param value
     * @return
     */
    public static Integer toInteger(Object value){
        return toInteger(value, null);
    }

    /**
     * 对象转Long
     * @param value
     * @param defaultValue
     * @return
     */
    public static Long toLong(Object value, Long defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Long){
            return (Long) value;
        }
        return Long.parseLong(value.toString());
    }

    /**
     * 对象转Long
     * @param value
     * @return
     */
    public static Long toLong(Object value){
        return toLong(value, null);
    }

    /**
     * 对象转BigDecimal
     * @param value
     * @param defaultValue
     * @return
     */
    public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof BigDecimal){
            return (BigDecimal) value;
        }
        return new BigDecimal(value.toString());
    }

    /**
     * 对象转BigDecimal
     * @param value
     * @return
     */
    public static BigDecimal toBigDecimal(Object value){
        return toBigDecimal(value, null);
    }

    /**
     * 对象转Byte
     * @param value
     * @param defaultValue
     * @return
     */
    public static Byte toByte(Object value, Byte defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Byte){
            return (Byte) value;
        }
        return Byte.parseByte(value.toString());
    }

    /**
     * 对象转Byte
     * @param value
     * @return
     */
    public static Byte toByte(Object value){
        return toByte(value, null);
    }

    /**
     * 对象转Byte
     * @param value
     * @param defaultValue
     * @return
     */
    public static Short toShort(Object value, Short defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Short){
            return (Short) value;
        }
        return Short.parseShort(value.toString());
    }

    /**
     * 对象转Short
     * @param value
     * @return
     */
    public static Short toShort(Object value){
        return toShort(value, null);
    }

    /**
     * 对象转double
     * @param value
     * @param defaultValue
     * @return
     */
    public static Double toDouble(Object value, Double defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Double){
            return (Double)value;
        }
        return Double.parseDouble(value.toString());
    }

    /**
     * 对象转换成Double
     * @param value
     * @return
     */
    public static Double toDouble(Object value){
        return toDouble(value, null);
    }

    /**
     * 对象转换成Float
     * @param value
     * @param defaultValue
     * @return
     */
    public static Float toFloat(Object value, Float defaultValue){
        if(null == value){
            return defaultValue;
        }
        if(value instanceof Float){
            return (Float)value;
        }
        return Float.parseFloat(value.toString());
    }

    /**
     * 对象转成Float
     * @param value
     * @return
     */
    public static Float toFloat(Object value){
        return toFloat(value, null);
    }

    /**
     * 对象转换成Character
     * @param value
     * @param defautlValue
     * @return
     */
    public static Character toCharacter(Object value, Character defautlValue){
        if(null == value){
            return defautlValue;
        }
        String valueStr = Convert.toString(value);
        if(1 == valueStr.length()){
            return valueStr.charAt(0);
        }
        return defautlValue;
    }

    /**
     * 对象转换成Character
     * @param value
     * @return
     */
    public static Character toCharacter(Object value){
        return toCharacter(value, null);
    }

    /**
     * 将该值转换成指定的类型
     * @param value
     * @param type
     * @param <T>
     * @return
     */
    public static <T>Object convert(String value, Class<?> type){
        if(null == value){
            return null;
        }

        if(String.class.equals(type)){
            return toString(value);
        }

        if(byte.class.equals(type) || Byte.class.equals(type)){
            return toByte(value);
        }

        if(short.class.equals(type) || Short.class.equals(type)){
            return toShort(value);
        }

        if(int.class.equals(type) || Integer.class.equals(type)){
            return toInteger(value);
        }

        if(long.class.equals(type) || Long.class.equals(type)){
            return toLong(value);
        }

        if(double.class.equals(type) || Double.class.equals(type)){
            return toDouble(type);
        }

        if(float.class.equals(type) || Float.class.equals(type)){
            return toFloat(value);
        }

        if(char.class.equals(type) || Character.class.equals(type)){
            return toCharacter(value);
        }

        if(boolean.class.equals(type) || Boolean.class.equals(type)){
            return toBoolean(value);
        }

        if(Date.class.equals(type)){
            try {
                return DateUtils.parse(value, DateUtils.newFormat);
            } catch (ParseException e) {
                throw new RuntimeException("不支持的日期类型转换", e);
            }
        }
        throw new RuntimeException("不支持的类型转换");
    }
}
